using System;
using System.IO;

namespace PickGold.BZip2
{
	/// <summary>
	/// BZip2 employs byte-shredding in its data format - rather than
	/// aligning all data items in a compressed .bz2 file on byte barriers,
	/// the BZip2 format uses portions of bytes to represent independent
	/// pieces of information. This "shredding" starts with the first
	/// "randomised" bit - just 12 bytes or so into a bz2 file or stream. But
	/// the approach is used extensively in bzip2 files - sometimes 5 bits
	/// are used, sometimes 24 or 3 bits, sometimes just 1 bit, and so on.
	/// It's not possible to send this information directly to a stream in
	/// this form; Streams in .NET accept byte-oriented input.  Therefore,
	/// when actually writing a bz2 file, the output data must be organized
	/// into a byte-aligned format before being written to the output stream.
	///
	/// This BitWriter class provides the byte-shredding necessary for BZip2
	/// output. Think of this class as an Adapter that enables Bit-oriented
	/// output to a standard byte-oriented .NET stream. This class writes
	/// data out to the captive output stream only after the data bits have
	/// been accumulated and aligned. For example, suppose that during
	/// operation, the BZip2 compressor emits 5 bits, then 24 bits, then 32
	/// bits.  When the first 5 bits are sent to the BitWriter, nothing is
	/// written to the output stream; instead these 5 bits are simply stored
	/// in the internal accumulator.  When the next 24 bits are written, the
	/// first 3 bits are gathered with the accumulated bits. The resulting
	/// 5+3 constitutes an entire byte; the BitWriter then actually writes
	/// that byte to the output stream. This leaves 21 bits. BitWriter writes
	/// 2 more whole bytes (16 more bits), in 8-bit chunks, leaving 5 in the
	/// accumulator. BitWriter then follows the same procedure with the 32
	/// new bits. And so on.
	///
	/// A quick tour of the implementation:
	///
	/// The accumulator is a uint - so it can accumulate at most 4 bytes of
	/// information. In practice because of the design of this class, it
	/// never accumulates more than 3 bytes.
	///
	/// The Flush() method emits all whole bytes available. After calling
	/// Flush(), there may be between 0-7 bits yet to be emitted into the
	/// output stream.
	///
	/// FinishAndPad() emits all data, including the last partial byte and
	/// any necessary padding. In effect, it establishes a byte-alignment
	/// barrier. To support bzip2, FinishAndPad() should be called only once
	/// for a bz2 file, after the last bit of data has been written through
	/// this adapter.  Other binary file formats may use byte-alignment at
	/// various points within the file, and FinishAndPad() would support that
	/// scenario.
	///
	/// The internal fn Reset() is used to reset the state of the adapter;
	/// this class is used by BZip2Compressor, instances of which get re-used
	/// by multiple distinct threads, for different blocks of data.
	/// </summary>
	internal class BitWriter
	{
		uint accumulator;
		int nAccumulatedBits;
		Stream output;
		int totalBytesWrittenOut;

		public BitWriter(Stream s)
		{
			this.output = s;
		}

		/// <summary>
		///   Delivers the remaining bits, left-aligned, in a byte.
		/// </summary>
		/// <remarks>
		///   <para>
		///     This is valid only if NumRemainingBits is less than 8;
		///     in other words it is valid only after a call to Flush().
		///   </para>
		/// </remarks>
		public byte RemainingBits
		{
			get
			{
				return (byte)(this.accumulator >> (32 - this.nAccumulatedBits) & 0xff);
			}
		}

		public int NumRemainingBits
		{
			get
			{
				return this.nAccumulatedBits;
			}
		}

		public int TotalBytesWrittenOut
		{
			get
			{
				return this.totalBytesWrittenOut;
			}
		}

		/// <summary>
		///   Reset the BitWriter.
		/// </summary>
		/// <remarks>
		///   <para>
		///     This is useful when the BitWriter writes into a MemoryStream, and
		///     is used by a BZip2Compressor, which itself is re-used for multiple
		///     distinct data blocks.
		///   </para>
		/// </remarks>
		public void Reset()
		{
			this.accumulator = 0;
			this.nAccumulatedBits = 0;
			this.totalBytesWrittenOut = 0;
			this.output.Seek(0, SeekOrigin.Begin);
			this.output.SetLength(0);
		}

		/// <summary>
		///   Write some number of bits from the given value, into the output.
		/// </summary>
		/// <remarks>
		///   <para>
		///     The nbits value should be a max of 25, for safety. For performance
		///     reasons, this method does not check!
		///   </para>
		/// </remarks>
		public void WriteBits(int nbits, uint value)
		{
			int nAccumulated = this.nAccumulatedBits;
			uint u = this.accumulator;

			while (nAccumulated >= 8)
			{
				this.output.WriteByte((byte)(u >> 24 & 0xff));
				this.totalBytesWrittenOut++;
				u <<= 8;
				nAccumulated -= 8;
			}

			this.accumulator = u | (value << (32 - nAccumulated - nbits));
			this.nAccumulatedBits = nAccumulated + nbits;

			// Console.WriteLine("WriteBits({0}, 0x{1:X2}) => {2:X8} n({3})",
			//                   nbits, value, accumulator, nAccumulatedBits);
			// Console.ReadLine();

			// At this point the accumulator may contain up to 31 bits waiting for
			// output.
		}


		/// <summary>
		///   Write a full 8-bit byte into the output.
		/// </summary>
		public void WriteByte(byte b)
		{
			WriteBits(8, b);
		}

		/// <summary>
		///   Write four 8-bit bytes into the output.
		/// </summary>
		public void WriteInt(uint u)
		{
			WriteBits(8, (u >> 24) & 0xff);
			WriteBits(8, (u >> 16) & 0xff);
			WriteBits(8, (u >> 8) & 0xff);
			WriteBits(8, u & 0xff);
		}

		/// <summary>
		///   Write all available byte-aligned bytes.
		/// </summary>
		/// <remarks>
		///   <para>
		///     This method writes no new output, but flushes any accumulated
		///     bits. At completion, the accumulator may contain up to 7
		///     bits.
		///   </para>
		///   <para>
		///     This is necessary when re-assembling output from N independent
		///     compressors, one for each of N blocks. The output of any
		///     particular compressor will in general have some fragment of a byte
		///     remaining. This fragment needs to be accumulated into the
		///     parent BZip2OutputStream.
		///   </para>
		/// </remarks>
		public void Flush()
		{
			WriteBits(0, 0);
		}


		/// <summary>
		///   Writes all available bytes, and emits padding for the final byte as
		///   necessary. This must be the last method invoked on an instance of
		///   BitWriter.
		/// </summary>
		public void FinishAndPad()
		{
			Flush();

			if (this.NumRemainingBits > 0)
			{
				byte b = (byte)((this.accumulator >> 24) & 0xff);
				this.output.WriteByte(b);
				this.totalBytesWrittenOut++;
			}
		}

	}

}
